home *** CD-ROM | disk | FTP | other *** search
/ Zoom 2 / Zoom - Release 2 (1996)(Active Software)[!].iso / programming / amiga / muibuilder / mb / developer / c / sources_gencodec / gencodecmain.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-16  |  11.0 KB  |  484 lines
  1. /* Main-Header File inserted by GenCodeC */
  2. /* Libraries */
  3. #include <libraries/mui.h>
  4. #include <libraries/gadtools.h> /* for BARLABEL in MenuItem */
  5.  
  6. /* Prototypes */
  7. #include <clib/muimaster_protos.h>
  8. #include <clib/exec_protos.h>
  9. #include <clib/alib_protos.h>
  10. #include <clib/dos_protos.h>
  11.  
  12.  
  13. /*  Pragmas  */
  14. #include <pragmas/muimaster_pragmas.h>
  15. #include <pragmas/exec_pragmas.h>
  16.  
  17. /*  Ansi  */
  18. #include <stdlib.h>
  19. #include <stdio.h>
  20. /* GenCodeC header end */
  21.  
  22. /* Include generated by GenCodeC */
  23. #include "GenCodeCGUI.h"
  24.  
  25. #include <exec/memory.h>
  26. #include <string.h>
  27.  
  28. #include "TextField.h"
  29. #include "Tools.h"
  30. #include "GenCodeC.h"
  31. #include "MB.h"
  32. #include "MB_pragmas.h"
  33. #include "MB_protos.h"
  34.  
  35. /* defines for header file */
  36. #define  HHEADER     1
  37. #define  CHEADER     2
  38. #define  MAINHEADER  3
  39.  
  40. #define  LOCALSAVE   1
  41. #define  GLOBALSAVE  2
  42.  
  43. /* Global variables */
  44. BOOL  TextFieldLocked = FALSE;
  45.  
  46. struct ObjTextField    *TF_H_Header;
  47. struct ObjTextField    *TF_C_Header;
  48. struct ObjTextField    *TF_Main_Header;
  49.  
  50. char     *H_Header_Text;
  51. char     *C_Header_Text;
  52. char     *Main_Header_Text;
  53.  
  54. static const char vers[] = "\0$VER: GenCodeC 2.2ß  27.09.95";
  55.  
  56. /* Declarations for libraries (inserted by GenCodeC) */
  57. struct Library * MUIMasterBase;
  58.  
  59. struct Library * DOSBase = NULL;
  60. struct Library * MUIBBase = NULL;
  61.  
  62. /* Init() function */
  63. void init( void )
  64. {
  65.     if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
  66.     {
  67.         DisplayMsg("Can't Open MUIMaster Library\n");
  68.         exit(20);
  69.     }
  70.  
  71.     if (!(DOSBase  = OpenLibrary("dos.library", 0)))
  72.     {
  73.         DisplayMsg("Can't Open Dos Library\n");
  74.         CloseLibrary(MUIMasterBase);
  75.         exit(20);
  76.     }
  77.  
  78.     if (!(MUIBBase = OpenLibrary("muibuilder.library", 0)))
  79.     {
  80.         DisplayMsg("Can't Open MUIBuilder Library\n");
  81.         CloseLibrary(MUIMasterBase);
  82.         CloseLibrary(DOSBase);
  83.         exit(20);
  84.     }
  85.     
  86.     /* exit if we can't init the Library */
  87.     if (!MB_Open())
  88.     {
  89.         DisplayMsg("Unable to Get Temporary files !\n");
  90.         MB_Close();
  91.         CloseLibrary(MUIMasterBase);
  92.         CloseLibrary(DOSBase);
  93.         CloseLibrary(MUIBBase);
  94.         exit(20);
  95.     }
  96. }
  97. /* GenCodeC init() end */
  98.  
  99. void UnlockTextFieldTexts(struct ObjTextField *,char *,struct ObjTextField *,char *,struct ObjTextField *,char *);
  100.  
  101. /* End() function */
  102. void end( void )
  103. {
  104.     MB_Close();    /* Free Memory and Close Temporary Files */
  105.  
  106.     if (TextFieldLocked)
  107.     {
  108.         UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  109.                              TF_C_Header,C_Header_Text,
  110.                              TF_Main_Header,Main_Header_Text);
  111.     }
  112.  
  113.     ClearMemory();
  114.  
  115.     CloseLibrary(MUIBBase);
  116.     CloseLibrary(DOSBase);
  117.     CloseLibrary(MUIMasterBase);
  118.     exit(20);
  119. }
  120. /* GenCodeC end() end */
  121.  
  122. /* Read a header file and load it in memory */
  123. char *LoadHeaderFile(int HeaderFile)
  124. {
  125.     char  *TMPFile;
  126.     char  *HF;
  127.     int   size;
  128.     char  *MBDir=NULL;
  129.     char  *FileName;
  130.     
  131.     MB_Get(MUIB_FileName,&FileName,TAG_END);
  132.     
  133.     /* Get Current Directory Name */
  134.     if (!(MBDir = GetCurrentDirectory()))
  135.     {
  136.         return NULL;
  137.     }
  138.       
  139.     size = strlen(MBDir)+1+9+1+strlen(FilePart(FileName))+12+1;
  140.     if (!(TMPFile = AllocMemory(size)))
  141.     {
  142.         FreeMemory(MBDir);
  143.         return NULL;
  144.     }
  145.     else
  146.     {
  147.         /* Try to read local header and if there's no local header, try to read global header */
  148.     
  149.         strcpy(TMPFile,MBDir);
  150.         AddPart(TMPFile,"C_Headers",size);
  151.         AddPart(TMPFile,FilePart(FileName),size);
  152.         remove_extend(TMPFile);
  153.         switch(HeaderFile)
  154.         {
  155.             case HHEADER:
  156.                 add_extend(TMPFile,".H-Header");
  157.                 break;
  158.             
  159.             case CHEADER:
  160.                 add_extend(TMPFile,".C-Header");
  161.                 break;
  162.             
  163.             case MAINHEADER:
  164.                 add_extend(TMPFile,".Main-Header");
  165.                 break;
  166.         }
  167.         if (!(HF = LoadFileInRAM(TMPFile,TRUE)))
  168.         {
  169.             FreeMemory(TMPFile);
  170.             size = strlen(MBDir)+1+9+1+12+1;
  171.             if (!(TMPFile = AllocMemory(size)))
  172.             {
  173.                 FreeMemory(MBDir);
  174.                 return NULL;
  175.             }
  176.             else
  177.             {
  178.                 strcpy(TMPFile,MBDir);
  179.                 AddPart(TMPFile,"C_Headers",size);
  180.                 switch(HeaderFile)
  181.                 {
  182.                     case HHEADER:
  183.                         AddPart(TMPFile,"H-Header",size);
  184.                         break;
  185.                     
  186.                     case CHEADER:
  187.                         AddPart(TMPFile,"C-Header",size);
  188.                         break;
  189.                     
  190.                     case MAINHEADER:
  191.                         AddPart(TMPFile,"Main-Header",size);
  192.                         break;
  193.                 }
  194.                 HF = LoadFileInRAM(TMPFile,FALSE);
  195.                 FreeMemory(MBDir);
  196.                 FreeMemory(TMPFile);
  197.                 return HF;
  198.             }
  199.         }
  200.         else
  201.         {
  202.             FreeMemory(MBDir);
  203.             FreeMemory(TMPFile);
  204.             return HF;
  205.         }
  206.     }
  207. }
  208.  
  209. /* Save a header file */
  210. void SaveHeaderFile(int HeaderFile,char *HeaderText,int PrefsSave)
  211. {
  212.     char  *TMPFile;
  213.     int   size;
  214.     char  *MBDir = NULL;
  215.     char  *FileName;
  216.     BOOL  Prefs = (PrefsSave==LOCALSAVE);
  217.     FILE  *file;
  218.     
  219.     MB_Get(MUIB_FileName,&FileName,TAG_END);
  220.     
  221.     /* Get Current Directory Name */
  222.     if (!(MBDir = GetCurrentDirectory()))
  223.     {
  224.         return;
  225.     }
  226.       
  227.     size = strlen(MBDir)+1+9+((Prefs) ? (1+strlen(FilePart(FileName))):1)+12+1;
  228.     if (!(TMPFile = AllocMemory(size)))
  229.     {
  230.         FreeMemory(MBDir);
  231.         return;
  232.     }
  233.     else
  234.     {
  235.         strcpy(TMPFile,MBDir);
  236.         AddPart(TMPFile,"C_Headers",size);
  237.         if (Prefs)
  238.         {
  239.             AddPart(TMPFile,FilePart(FileName),size);
  240.             remove_extend(TMPFile);
  241.         }
  242.         switch(HeaderFile)
  243.         {
  244.             case HHEADER:
  245.                 (Prefs) ? add_extend(TMPFile,".H-Header") : AddPart(TMPFile,"H-Header",size);
  246.                 break;
  247.             
  248.             case CHEADER:
  249.                 (Prefs) ? add_extend(TMPFile,".C-Header") : AddPart(TMPFile,"C-Header",size);
  250.                 break;
  251.             
  252.             case MAINHEADER:
  253.                 (Prefs) ? add_extend(TMPFile,".Main-Header") : AddPart(TMPFile,"Main-Header",size);
  254.                 break;
  255.         }
  256.         if (file = fopen(TMPFile,"w"))
  257.         {
  258.             FreeMemory(MBDir);
  259.             FreeMemory(TMPFile);
  260.             fwrite(HeaderText,1,strlen(HeaderText),file);
  261.             fclose(file);
  262.         }
  263.     }
  264. }
  265.  
  266. void CreateTextFieldObjects(struct ObjApp *App,
  267.                             struct ObjTextField **TF_H_Header,
  268.                             struct ObjTextField **TF_C_Header,
  269.                             struct ObjTextField **TF_Main_Header)
  270. {
  271.     char  *HeaderText;
  272.     
  273.     if (!(*TF_H_Header = CreateTextField()))
  274.     {
  275.         DisplayMsg("Can't Create Textfield object\n");
  276.         DisposeApp(App);
  277.         end();
  278.     }
  279.     DoMethod(App->GR_H_Header, OM_ADDMEMBER, (*TF_H_Header)->textfield);
  280.     HeaderText = LoadHeaderFile(HHEADER);
  281.     if (HeaderText)
  282.     {
  283.         set((*TF_H_Header)->text,TEXTFIELD_Text,HeaderText);
  284.         FreeMemory(HeaderText);
  285.     }
  286.     
  287.     if (!(*TF_C_Header = CreateTextField()))
  288.     {
  289.         DisplayMsg("Can't Create Textfield object\n");
  290.         DisposeTextField(*TF_H_Header);
  291.         DisposeApp(App);
  292.         end();
  293.     }
  294.     DoMethod(App->GR_C_Header, OM_ADDMEMBER, (*TF_C_Header)->textfield);
  295.     HeaderText = LoadHeaderFile(CHEADER);
  296.     if (HeaderText)
  297.     {
  298.         set((*TF_C_Header)->text,TEXTFIELD_Text,HeaderText);
  299.         FreeMemory(HeaderText);
  300.     }
  301.     
  302.     if (!(*TF_Main_Header = CreateTextField()))
  303.     {
  304.         DisplayMsg("Can't Create Textfield object\n");
  305.         DisposeTextField(*TF_H_Header);
  306.         DisposeTextField(*TF_C_Header);
  307.         DisposeApp(App);
  308.         end();
  309.     }
  310.     DoMethod(App->GR_Main_Header, OM_ADDMEMBER, (*TF_Main_Header)->textfield);
  311.     HeaderText = LoadHeaderFile(MAINHEADER);
  312.     if (HeaderText)
  313.     {
  314.         set((*TF_Main_Header)->text,TEXTFIELD_Text,HeaderText);
  315.         FreeMemory(HeaderText);
  316.     }
  317. }
  318.  
  319. void LockTextFieldTexts(struct ObjApp *App,
  320.                         struct ObjTextField *TF_H_Header,char **H_Header_Text,
  321.                         struct ObjTextField *TF_C_Header,char **C_Header_Text,
  322.                         struct ObjTextField *TF_Main_Header,char **Main_Header_Text)
  323. {
  324.     char  *text;
  325.     ULONG    size;
  326.     
  327.     set(TF_H_Header->text,TEXTFIELD_ReadOnly,TRUE);
  328.     set(TF_C_Header->text,TEXTFIELD_ReadOnly,TRUE);
  329.     set(TF_Main_Header->text,TEXTFIELD_ReadOnly,TRUE);
  330.     
  331.     get(TF_H_Header->text,TEXTFIELD_Size,&size);
  332.     get(TF_H_Header->text,TEXTFIELD_Text,&text);
  333.     if (!(*H_Header_Text = AllocMemory(size+1)))
  334.     {
  335.         DisposeTextField(TF_H_Header);
  336.         DisposeTextField(TF_C_Header);
  337.         DisposeTextField(TF_Main_Header);
  338.         DisposeApp(App);
  339.         end();
  340.     }
  341.     strncpy(*H_Header_Text,text,size);
  342.     (*H_Header_Text)[size]='\0';
  343.     
  344.     get(TF_C_Header->text,TEXTFIELD_Size,&size);
  345.     get(TF_C_Header->text,TEXTFIELD_Text,&text);
  346.     if (!(*C_Header_Text = AllocMemory(size+1)))
  347.     {
  348.         FreeMemory(*H_Header_Text);
  349.         DisposeTextField(TF_H_Header);
  350.         DisposeTextField(TF_C_Header);
  351.         DisposeTextField(TF_Main_Header);
  352.         DisposeApp(App);
  353.         end();
  354.     }
  355.     strncpy(*C_Header_Text,text,size);
  356.     (*C_Header_Text)[size]='\0';
  357.     
  358.     get(TF_Main_Header->text,TEXTFIELD_Size,&size);
  359.     get(TF_Main_Header->text,TEXTFIELD_Text,&text);
  360.     if (!(*Main_Header_Text = AllocMemory(size+1)))
  361.     {
  362.         FreeMemory(*H_Header_Text);
  363.         FreeMemory(*C_Header_Text);
  364.         DisposeTextField(TF_H_Header);
  365.         DisposeTextField(TF_C_Header);
  366.         DisposeTextField(TF_Main_Header);
  367.         DisposeApp(App);
  368.         end();
  369.     }
  370.     strncpy(*Main_Header_Text,text,size);
  371.     (*Main_Header_Text)[size]='\0';
  372.  
  373.     TextFieldLocked = TRUE;
  374. }
  375.  
  376. void UnlockTextFieldTexts(struct ObjTextField *TF_H_Header,char *H_Header_Text,
  377.                             struct ObjTextField *TF_C_Header,char *C_Header_Text,
  378.                             struct ObjTextField *TF_Main_Header,char *Main_Header_Text)
  379. {
  380.     set(TF_H_Header->text,TEXTFIELD_ReadOnly,FALSE);
  381.     set(TF_C_Header->text,TEXTFIELD_ReadOnly,FALSE);
  382.     set(TF_Main_Header->text,TEXTFIELD_ReadOnly,FALSE);
  383.     
  384.     FreeMemory(H_Header_Text);
  385.     FreeMemory(C_Header_Text);
  386.     FreeMemory(Main_Header_Text);
  387.  
  388.     TextFieldLocked = FALSE;
  389. }
  390.  
  391. /* Main Function inserted by GenCodeC */
  392. int main(int argc,char **argv)
  393. {
  394.     struct ObjApp        * App = NULL; /* Object */
  395.     BOOL                running = TRUE;
  396.     ULONG                signal;
  397.     BOOL                Locale;
  398.  
  399.     /* Program initialisation : generated by GenCodeC */
  400.     init();
  401.     
  402.     /* Create Object : generated by GenCodeC */
  403.     if (!(App = CreateApp()))
  404.     {
  405.         DisplayMsg("Can't Create App\n");
  406.         end();
  407.     }
  408.     
  409.     CreateTextFieldObjects(App,&TF_H_Header,&TF_C_Header,&TF_Main_Header);
  410.  
  411.     MB_Get(MUIB_Locale,&Locale,TAG_DONE);
  412.     if (!Locale)
  413.         set(App->GR_Catalog,MUIA_ShowMe,FALSE);
  414.     
  415.     set(App->WI_C_Generation,
  416.         MUIA_Window_Open, TRUE
  417.         );
  418.     
  419.     while (running)
  420.     {
  421.         switch (DoMethod(App->App,MUIM_Application_Input,&signal))
  422.         {
  423.             case MUIV_Application_ReturnID_Quit:
  424.             running = FALSE;
  425.             break;
  426.             
  427.             /* Insert your code between the "case" statement and comment "end of case ..." */
  428.             case ID_BT_SAVE_LOCAL:
  429.             {
  430.                 LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
  431.                                        TF_C_Header,&C_Header_Text,
  432.                                        TF_Main_Header,&Main_Header_Text);
  433.                     
  434.                 SaveHeaderFile(HHEADER,H_Header_Text,LOCALSAVE);
  435.                 SaveHeaderFile(CHEADER,C_Header_Text,LOCALSAVE);
  436.                 SaveHeaderFile(MAINHEADER,Main_Header_Text,LOCALSAVE);
  437.                     
  438.                 UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  439.                                      TF_C_Header,C_Header_Text,
  440.                                      TF_Main_Header,Main_Header_Text);
  441.             }
  442.             break;
  443.             /* end of case ID_BT_SAVE_LOCAL */
  444.  
  445.             case ID_BT_SAVE_GLOBAL:
  446.             {
  447.                 LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
  448.                                        TF_C_Header,&C_Header_Text,
  449.                                        TF_Main_Header,&Main_Header_Text);
  450.                     
  451.                 SaveHeaderFile(HHEADER,H_Header_Text,GLOBALSAVE);
  452.                 SaveHeaderFile(CHEADER,C_Header_Text,GLOBALSAVE);
  453.                 SaveHeaderFile(MAINHEADER,Main_Header_Text,GLOBALSAVE);
  454.                     
  455.                 UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  456.                                      TF_C_Header,C_Header_Text,
  457.                                      TF_Main_Header,Main_Header_Text);
  458.             }
  459.             break;
  460.             /* end of case ID_BT_SAVE_GLOBAL */
  461.  
  462.             case ID_BT_GENERATE:
  463.             {    
  464.                 LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
  465.                                        TF_C_Header,&C_Header_Text,
  466.                                        TF_Main_Header,&Main_Header_Text);
  467.                     
  468.                 GenerateCode(App,H_Header_Text,C_Header_Text,Main_Header_Text);
  469.                     
  470.                 UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  471.                                      TF_C_Header,C_Header_Text,
  472.                                      TF_Main_Header,Main_Header_Text);
  473.             }
  474.             break;
  475.             /* end of case ID_BT_GENERATE */
  476.  
  477.             /* End computing of IDCMP */
  478.         }
  479.         if (running && signal) Wait(signal);
  480.     }
  481.     DisposeApp(App);
  482.     end();
  483. }
  484.